using System.Collections.Generic;
using SIP.PN.DAO.Interfaces;
using SIP.PN.Filtros.Interfaces;
using SIP.PN.Modelo.Entidades;
using SIP.PN.Servicios.Interfaces;
using SIP.PN.Servicios.Interfaces.DTO;
using SIP.PN.Servicios.Interfaces.Excepciones;

namespace SIP.PN.Servicios
{
    public class ServicioTipoDeProyecto : Servicio, IServicioTipoDeProyecto
    {
        #region Daos

        private IDaoTipoDeProyecto daoTipoDeProyecto;
        public IDaoTipoDeProyecto DaoTipoDeProyecto
        {
            get { return daoTipoDeProyecto; }
            set { daoTipoDeProyecto = value; }
        }

        private IDaoConcepto daoConcepto;
        public IDaoConcepto DaoConcepto
        {
            get { return daoConcepto; }
            set { daoConcepto = value; }
        }

        #endregion

        #region Tipo De Proyecto

        public IList<TipoDeProyectoDTO> Listar()
        {
            IFiltroTipoDeProyecto filtro = ObtenerFiltro<IFiltroTipoDeProyecto>();
            filtro.AgregarOrden("Nombre", true);
            IList<TipoDeProyectoDTO> r = new List<TipoDeProyectoDTO>();
            foreach (TipoDeProyecto item in DaoTipoDeProyecto.Listar(filtro))
            {
                r.Add(ConvertToDTO(item));
            }
            return r;
        }

        public IList<TipoDeProyectoDTO> Listar(string orden, int desde, int cantidad, string codigo, string nombre)
        {
            IFiltroTipoDeProyecto filtro = ObtenerFiltro<IFiltroTipoDeProyecto>();
            filtro.Cantidad = cantidad;
            filtro.Desde = desde;

            if (!string.IsNullOrEmpty(orden))
            {
                if (orden.EndsWith(" DESC"))
                {
                    filtro.AgregarOrden(orden.Substring(0, orden.Length - 5), false);
                }
                else
                {
                    filtro.AgregarOrden(orden, true);
                }
            }

            filtro.Codigo = codigo;
            filtro.Nombre = nombre;
            IList<TipoDeProyectoDTO> r = new List<TipoDeProyectoDTO>();
            foreach (TipoDeProyecto item in DaoTipoDeProyecto.Listar(filtro))
            {
                r.Add(ConvertToDTO(item));
            }
            return r;
        }

        public int ObtenerCantidadRegistros(string codigo, string nombre)
        {
            IFiltroTipoDeProyecto filtro = ObtenerFiltro<IFiltroTipoDeProyecto>();
            filtro.Codigo = codigo;
            filtro.Nombre = nombre;
            return DaoTipoDeProyecto.ObtenerCantidadRegistros(filtro);
        }

        public TipoDeProyectoDTO Obtener(string codigo)
        {
            return ConvertToDTO(DaoTipoDeProyecto.Obtener(codigo));
        }

        public virtual void Crear(string codigo, string nombre)
        {
            if (Obtener(codigo) != null)
                throw new ExcepcionCodigoUtilizado();

            TipoDeProyecto entidad = new TipoDeProyecto();
            entidad.Codigo = codigo;
            entidad.Nombre = nombre;
            DaoTipoDeProyecto.Guardar(entidad);
        }

        public virtual void Modificar(string codigo, string nombre)
        {
            TipoDeProyecto entidad = DaoTipoDeProyecto.Obtener(codigo);
            if (entidad == null)
                throw new ExcepcionOtra("No existe el tipo de proyecto.");
            entidad.Nombre = nombre;
            DaoTipoDeProyecto.Guardar(entidad);
        }

        public virtual void Eliminar(string codigo)
        {
            TipoDeProyecto entidad = DaoTipoDeProyecto.Obtener(codigo);
            if (entidad == null)
                throw new ExcepcionOtra("No existe el tipo de proyecto.");
            DaoTipoDeProyecto.Eliminar(entidad);
        }

        #endregion

        #region Concepto

        public IList<TipoConceptoDTO> ListarTipoConcepto()
        {
            IList<TipoConceptoDTO> r = new List<TipoConceptoDTO>();
            r.Add(new TipoConceptoDTO("COMPARTIDO", "COMPARTIDO"));
            r.Add(new TipoConceptoDTO("TAREA", "TAREA"));
            r.Add(new TipoConceptoDTO("OPERARIO", "OPERARIO"));
            return r;
        }
      
        public ConceptoDTO ObtenerConcepto(string codigo)
        {
            return ConvertToDTO(DaoConcepto.Obtener(codigo));
        }

        public virtual void AgregarConcepto(string codigoTipoDeProyecto, string codigoConcepto, string tipo, string nombre, string descripcion)
        {
            TipoDeProyecto entidad = DaoTipoDeProyecto.Obtener(codigoTipoDeProyecto);
            if (entidad == null)
                throw new ExcepcionOtra("No existe el tipo de proyecto.");
            entidad.AgregarConcepto(codigoConcepto, tipo, nombre, descripcion);
            DaoTipoDeProyecto.Guardar(entidad);
        }

        public virtual void ModificarConcepto(string codigoTipoDeProyecto, string codigoConcepto, string nombre, string descripcion)
        {
            TipoDeProyecto entidad = DaoTipoDeProyecto.Obtener(codigoTipoDeProyecto);
            if (entidad == null)
                throw new ExcepcionOtra("No existe el tipo de proyecto.");
            Concepto concepto = entidad.ObtenerConcepto(codigoConcepto);
            if (entidad == null)
                throw new ExcepcionOtra("No existe el concepto.");
            concepto.Nombre = nombre;
            concepto.Descripcion = descripcion;
            DaoTipoDeProyecto.Guardar(entidad);
        }

        public virtual void EliminarConcepto(string codigoTipoDeProyecto, string codigoConcepto)
        {
            TipoDeProyecto entidad = DaoTipoDeProyecto.Obtener(codigoTipoDeProyecto);
            if (entidad == null)
                throw new ExcepcionOtra("No existe el tipo de proyecto.");
            entidad.EliminarConcepto(codigoConcepto);
            DaoTipoDeProyecto.Guardar(entidad);
        }

        #endregion
    }
}
